package com.bfxy.esjob.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.bfxy.esjob.listener.SimpleJobListener;
import com.bfxy.esjob.task.MySimpleJob;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.event.JobEventConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.lite.spring.api.SpringJobScheduler;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;

//@Configuration
public class MySimpleJobConfig {

	@Autowired
	private ZookeeperRegistryCenter registryCenter;

	//
	@Autowired
	private JobEventConfiguration jobEventConfiguration;
	
	/**
	 * 	具体真正的定时任务执行逻辑
	 * 	自己的定时任务要做什么业务逻辑
	 * @return
	 */
	@Bean
	public SimpleJob simpleJob() {
		return new MySimpleJob();
	}
	
	/**
	 * 配置 定时任务
	 * JobScheduler 用来运行Job （在什么时间点执行啊等等）
	 * 核心： 如何创建 JobScheduler
	 * @param simpleJob
	 * @return
	 */
	@Bean(initMethod = "init")
	public JobScheduler simpleJobScheduler(final SimpleJob simpleJob,
			@Value("${simpleJob.cron}") final String cron,
			@Value("${simpleJob.shardingTotalCount}") final int shardingTotalCount,
			@Value("${simpleJob.shardingItemParameters}") final String shardingItemParameters,
			@Value("${simpleJob.jobParameter}") final String jobParameter,
			@Value("${simpleJob.failover}") final boolean failover,
			@Value("${simpleJob.monitorExecution}") final boolean monitorExecution,
			@Value("${simpleJob.monitorPort}") final int monitorPort,
			@Value("${simpleJob.maxTimeDiffSeconds}") final int maxTimeDiffSeconds,
			@Value("${simpleJob.jobShardingStrategyClass}") final String jobShardingStrategyClass) {
		// SpringJobScheduler 当当网与Spring的集成
		/**
		 * simpleJob : 具体要执行的任务，就是上面的 public SimpleJob simpleJob()
		 * registryCenter ： 传入具体的注册中心
		 * getLiteJobConfiguration ： 配置项
		 * jobEventConfiguration ： 执行的Job需要做一些链路的跟踪，就可以使用该对象 (日志）
		 * new SimpleJobListener() ： 实现了当当网的ElasticJobListener接口，是对定时任务方法执行体的切入
		 * （执行前，执行后）
		 */
		return new SpringJobScheduler(simpleJob,
				registryCenter,
				getLiteJobConfiguration(simpleJob.getClass(),
						cron,
						shardingTotalCount,
						shardingItemParameters,
						jobParameter,
						failover,
						monitorExecution,
						monitorPort,
						maxTimeDiffSeconds,
						jobShardingStrategyClass),
				jobEventConfiguration,
				new SimpleJobListener());
		
	}


	private LiteJobConfiguration getLiteJobConfiguration(Class<? extends SimpleJob> jobClass, String cron,
			int shardingTotalCount, String shardingItemParameters, String jobParameter, boolean failover,
			boolean monitorExecution, int monitorPort, int maxTimeDiffSeconds, String jobShardingStrategyClass) {

		/**
		 * 首先要创建 JobConfiguration，使用建造者模式创建
		 * 这边是设置一些配置参数
		 */
		JobCoreConfiguration jobCoreConfiguration = JobCoreConfiguration
				.newBuilder(jobClass.getName(), cron, shardingTotalCount)
				.misfire(true)
				.failover(failover)
				.jobParameter(jobParameter)
				.shardingItemParameters(shardingItemParameters)
				.build();

		// 还需要传入 Job的ClassName
		SimpleJobConfiguration simpleJobConfiguration = new SimpleJobConfiguration(jobCoreConfiguration, jobClass.getCanonicalName());

		// 创建LiteJobConfiguration，这边设置的是SimpleJobConfiguration
		// 好像是不同的 JonConfiguration可以设置的参数不同
		LiteJobConfiguration liteJobConfiguration = LiteJobConfiguration.newBuilder(simpleJobConfiguration)
				.jobShardingStrategyClass(jobShardingStrategyClass)
				.monitorExecution(monitorExecution)
				.monitorPort(monitorPort)
				.maxTimeDiffSeconds(maxTimeDiffSeconds)
				.overwrite(false) // 以本地为主
				.build();
		
		return liteJobConfiguration;
	}
	
	
	
	
	
	
}
